1. Field of the Invention
The present invention generally relates to direct manipulation of graphical objects on a visual display for a computing system. It focuses specifically on graphical objects that are hierarchically composed of other graphical objects, any one of which may have direct manipulation properties relative to other graphical objects. It specifies a definition for direct manipulation between two or more distinct objects of this type, focusing specifically on the defined direct manipulations between the graphical objects composing them. A process for detecting which manipulations take precedence in practice is specified. The end process simplifies direct manipulation in these circumstances as well as makes these interactions more intuitive.
2. Background Description
Direct manipulation, also referred to as drag-drop, in window-based systems has existed for many years. Direct manipulation concerns the relationship between any two graphical elements on a display screen and how they interact when one is dragged over and possibly dropped onto the other. This relationship is programmed into an application or system relating to the graphical elements. It is this programming which both allows or disallows the dragging over, as well as implements a semantic meaning to the drop operation.
The specification of direct manipulation relationships, being programmed in detail per application, is tedious, difficult, and prone to errors. It requires the specification of a number of programming elements, such as specialized data structures and display images, and its programming is usually fragmented into several phases such as initialize drag, dragging-over, and drag-drop. All of this makes the specification of direct manipulation difficult and non-intuitive.
The direct manipulation of graphical objects is especially useful in the area of visual programming languages. The motivation behind visual programming language technology is to utilize visual representations of programming elements to build and generate programs. The field is very large. Generally however, the approaches to visual programming may be classified into the following:
Visual Designersxe2x80x94These are visual programming languages, which focus on the construction of user interface applications. Much of the focus is on interface form and presentation construction with caveats for generating event code to facilitate textual programming of other parts of an application.
Wiring-Based Languagesxe2x80x94These languages have visual representations of programming entities, such as objects or processes. Programming proceeds by creating and connecting visual representations with lines, which typically indicate data or event flow.
Structured-Logic Basedxe2x80x94These focus on structuring the logic of a program. Typically logic is represented with nested graphical figures which represent logical entities, e.g. if, loops, etc. Typically visual representations of programming objects are not shown in these tools.
Form-Basedxe2x80x94These are visual programming languages of the spreadsheet genre. Typically represented as grids or arrays of numbers, a textual macro language typically accompanies the language to do more complex manipulations.
Most visual programming languages are wiring-based. The power of this type of language resides in its ability to represent parallelism. That is, its power is its ability to show either simultaneous, concurrent, or alternate possible executions at the same time. The focus of these types of languages has been a connection paradigm (wires) which generally indicates either event or data flow.
Whereas the connectivity aspect is the chief asset of these languages, it is also its greatest liability. Wirebased language programs become difficult to decipher even in modestly complex examples, as the causal nature of execution rapidly gets lost in the implicit parallelism of the diagram. Also, the visual element that represents the object tends to be limited. Generally, they are either named boxes representing variables, or in iconic representations. In this case, the true dynamic of the language is in connecting these representations, not working with them. At heart, these are execution-based languages to which the data model is secondary. Much more could be gained from clearer and more expansive object detail as interaction amongst visual details could lead to larger interpretations of corresponding inter-programming object possibilities. As a simple example, cross object property assignment could be done with a simple drag-drop operation on graphical elements representing the source and target properties of the corresponding programming objects.
While direct manipulation has been very successful as a visual paradigm, one can run into problematic situations. One situation in particular is when graphical elements are nested within other graphical elements, and one wants to do drag-drop with inner nested elements. The nesting aspect of graphical elements intuitively indicates that inner elements are xe2x80x9cpart ofxe2x80x9d outer elements. However, defined behavior of direct manipulation amongst graphical elements is independent of that, for instance, when dragging and dropping is allowed between graphical elements independently of the nesting of graphical elements. In many cases, it would be expedient and practical for an application to have a graphical element delegate the dragging and dropping capabilities to its parent. For example, in dragging an inner element over an element that allows the inner""s parent to be dropped but not the inner itself. In that situation, it would be intuitive to interpret this as a dragging of that parent and allow the drop. The containment is intuitively sufficient to justify this action. A statement of when similar actions should occur is a formulation of a resolution policy on direct manipulation that is the subject of this invention.
It is therefore an objective of the present invention to provide a method and apparatus for applying a resolution policy for direct manipulation. This policy would resolve the allowance or disallowance of dragging and dropping of a graphical element onto another. This is particularly useful when applied to hierarchically structured visuals, wherein nested graphical elements may delegate direct manipulation to parent graphical elements.
According to the invention, a guest visual object is to be manipulated with respect to a host visual object. Typically, the guest object is dragged over and/or dropped onto the host visual object. The guest and host visual objects may be nested within other visual objects. If a first visual object is immediately nested inside of a second visual object, then the first visual object is called the child object and the second visual object is called the parent object.
A number of allowed manipulations are defined for the guest and host visual objects. A guest visual object may not have a defined manipulation with a host visual object, but the guest""s immediate parent might. The present invention resolves policies for defining allowed manipulations for guest and host visual objects that do not have direct definitions for manipulations and must rely on definitions attributed to their parent.
The resolution policy of the preferred embodiment of the invention first determines whether any object in the chain of parents and children for the guest visual object have defined manipulations with the host visual object before looking to the parent of the host visual object for a definition. This policy could also be defined to traverse the host visual object first, for each guest visual object. Similarly, it is not necessary to traverse the chain from bottom up, i.e., the oldest parent could be checked first before the most immediate parent.
Once the desired manipulation has been resolved as allowed or disallowed, the graphical display is updated in a desired manner to indicate the results of the resolution. For instance, if a dragging-over or dropping is not allowed, the cursor could be modified, or the screen could blink in alternating patterns of light and dark, or positive and reverse images. When a visual object is dragged a special drag image could be displayed. Similarly, when a visual object is dropped the graphical displayed is updated to reflect its new location.